21 research outputs found
Understanding, Analysis, and Handling of Software Architecture Erosion
Architecture erosion occurs when a software system's implemented architecture diverges from the intended architecture over time. Studies show erosion impacts development, maintenance, and evolution since it accumulates imperceptibly. Identifying early symptoms like architectural smells enables managing erosion through refactoring. However, research lacks comprehensive understanding of erosion, unclear which symptoms are most common, and lacks detection methods. This thesis establishes an erosion landscape, investigates symptoms, and proposes identification approaches. A mapping study covers erosion definitions, symptoms, causes, and consequences. Key findings: 1) "Architecture erosion" is the most used term, with four perspectives on definitions and respective symptom types. 2) Technical and non-technical reasons contribute to erosion, negatively impacting quality attributes. Practitioners can advocate addressing erosion to prevent failures. 3) Detection and correction approaches are categorized, with consistency and evolution-based approaches commonly mentioned.An empirical study explores practitioner perspectives through communities, surveys, and interviews. Findings reveal associated practices like code review and tools identify symptoms, while collected measures address erosion during implementation. Studying code review comments analyzes erosion in practice. One study reveals architectural violations, duplicate functionality, and cyclic dependencies are most frequent. Symptoms decreased over time, indicating increased stability. Most were addressed after review. A second study explores violation symptoms in four projects, identifying 10 categories. Refactoring and removing code address most violations, while some are disregarded.Machine learning classifiers using pre-trained word embeddings identify violation symptoms from code reviews. Key findings: 1) SVM with word2vec achieved highest performance. 2) fastText embeddings worked well. 3) 200-dimensional embeddings outperformed 100/300-dimensional. 4) Ensemble classifier improved performance. 5) Practitioners found results valuable, confirming potential.An automated recommendation system identifies qualified reviewers for violations using similarity detection on file paths and comments. Experiments show common methods perform well, outperforming a baseline approach. Sampling techniques impact recommendation performance
Code Reviewer Recommendation for Architecture Violations: An Exploratory Study
Code review is a common practice in software development and often conducted
before code changes are merged into the code repository. A number of approaches
for automatically recommending appropriate reviewers have been proposed to
match such code changes to pertinent reviewers. However, such approaches are
generic, i.e., they do not focus on specific types of issues during code
reviews. In this paper, we propose an approach that focuses on architecture
violations, one of the most critical type of issues identified during code
review. Specifically, we aim at automating the recommendation of code
reviewers, who are potentially qualified to review architecture violations,
based on reviews of code changes. To this end, we selected three common
similarity detection methods to measure the file path similarity of code
commits and the semantic similarity of review comments. We conducted a series
of experiments on finding the appropriate reviewers through evaluating and
comparing these similarity detection methods in separate and combined ways with
the baseline reviewer recommendation approach, RevFinder. The results show that
the common similarity detection methods can produce acceptable performance
scores and achieve a better performance than RevFinder. The sampling techniques
used in recommending code reviewers can impact the performance of reviewer
recommendation approaches. We also discuss the potential implications of our
findings for both researchers and practitioners.Comment: The 27th International Conference on Evaluation and Assessment in
Software Engineering (EASE
Warnings: Violation Symptoms Indicating Architecture Erosion
As a software system evolves, its architecture tends to degrade, and
gradually impedes software maintenance and evolution activities and negatively
impacts the quality attributes of the system. The main root cause behind
architecture erosion phenomenon derives from violation symptoms (such as
violations of architecture pattern). Previous studies focus on detecting
violations in software systems using architecture conformance checking
approaches. However, code review comments are also rich sources that may
contain extensive discussions regarding architecture violations. In this work,
we investigated the characteristics of architecture violation symptoms in code
review comments from the developers' perspective. We employed a set of keywords
related to violation symptoms to collect 606 (out of 21,583) code review
comments from four popular OSS projects in the OpenStack and Qt communities. We
manually analyzed the collected 606 review comments to provide the categories
and linguistic patterns of violation symptoms, as well as the reactions how
developers addressed them. Our findings show that: (1) 10 categories of
violation symptoms are discussed by developers during the code review process;
(2) The frequently-used terms of expressing violation symptoms are
"inconsistent" and "violate", and the most frequently-used linguistic pattern
is Problem Discovery; (3) Refactoring and removing code are the major measures
(90%) to tackle violation symptoms, while a few violation symptoms were ignored
by developers. Our findings suggest that the investigation of violation
symptoms can help researchers better understand the characteristics of
architecture erosion and facilitate the development and maintenance activities,
and developers should explicitly manage violation symptoms, not only for
addressing the existing architecture violations but also preventing future
violations.Comment: Preprint accepted for publication in Information and Software
Technology, 202
Towards Automatic Identification of Violation Symptoms of Architecture Erosion
Architecture erosion has a detrimental effect on maintenance and evolution,
as the implementation drifts away from the intended architecture. To prevent
this, development teams need to understand early enough the symptoms of
erosion, and particularly violations of the intended architecture. One way to
achieve this, is through the automatic identification of architecture
violations from textual artifacts, and particularly code reviews. In this
paper, we developed 15 machine learning-based and 4 deep learning-based
classifiers with three pre-trained word embeddings to identify violation
symptoms of architecture erosion from developer discussions in code reviews.
Specifically, we looked at code review comments from four large open-source
projects from the OpenStack (Nova and Neutron) and Qt (Qt Base and Qt Creator)
communities. We then conducted a survey to acquire feedback from the involved
participants who discussed architecture violations in code reviews, to validate
the usefulness of our trained classifiers. The results show that the SVM
classifier based on word2vec pre-trained word embedding performs the best with
an F1-score of 0.779. In most cases, classifiers with the fastText pre-trained
word embedding model can achieve relatively good performance. Furthermore,
200-dimensional pre-trained word embedding models outperform classifiers that
use 100 and 300-dimensional models. In addition, an ensemble classifier based
on the majority voting strategy can further enhance the classifier and
outperforms the individual classifiers. Finally, an online survey of the
involved developers reveals that the violation symptoms identified by our
approaches have practical value and can provide early warnings for impending
architecture erosion.Comment: 20 pages, 4 images, 7 tables, Revision submitted to TSE (2023
Understanding Architecture Erosion: The Practitioners' Perceptive
As software systems evolve, their architecture is meant to adapt accordingly
by following the changes in requirements, the environment, and the
implementation. However, in practice, the evolving system often deviates from
the architecture, causing severe consequences to system maintenance and
evolution. This phenomenon of architecture erosion has been studied extensively
in research, but not yet been examined from the point of view of developers. In
this exploratory study, we look into how developers perceive the notion of
architecture erosion, its causes and consequences, as well as tools and
practices to identify and control architecture erosion. To this end, we
searched through several popular online developer communities for collecting
data of discussions related to architecture erosion. Besides, we identified
developers involved in these discussions and conducted a survey with 10
participants and held interviews with 4 participants. Our findings show that:
(1) developers either focus on the structural manifestation of architecture
erosion or on its effect on run-time qualities, maintenance and evolution; (2)
alongside technical factors, architecture erosion is caused to a large extent
by non-technical factors; (3) despite the lack of dedicated tools for detecting
architecture erosion, developers usually identify erosion through a number of
symptoms; and (4) there are effective measures that can help to alleviate the
impact of architecture erosion.Comment: The 29th IEEE/ACM International Conference on Program Comprehension
(ICPC
Automatic Identification of Assumptions from the Hibernate Developer Mailing List
During the software development life cycle, assumptions are an important type of software development knowledge that can be extracted from textual artifacts. Analyzing assumptions can help to, for example, comprehend software design and further facilitate software maintenance. Manual identification of assumptions by stakeholders is rather time-consuming, especially when analyzing a large dataset of textual artifacts. To address this problem, one promising way is to use automatic techniques for assumption identification. In this study, we conducted an experiment to evaluate the performance of existing machine learning classification algorithms for automatic assumption identification, through a dataset extracted from the Hibernate developer mailing list. The dataset is composed of 400 'Assumption' sentences and 400 'Non-Assumption' sentences. Seven classifiers using different machine learning algorithms were selected and evaluated. The experiment results show that the SVM algorithm achieved the best performance (with a precision of 0.829, a recall of 0.812, and an F1-score of 0.819). Additionally, according to the ROC curves and related AUC values, the SVM-based classifier comparatively performed better than other classifiers for the binary classification of assumptions.</p
Warnings:Violation symptoms indicating architecture erosion
As a software system evolves, its architecture tends to degrade, and gradually impedes software maintenance and evolution activities and negatively impacts the quality attributes of the system. The main root cause behind architecture erosion phenomenon derives from violation symptoms (i.e., various architecturally-relevant violations, such as violations of architecture pattern). Previous studies focus on detecting violations in software systems using architecture conformance checking approaches. However, code review comments are also rich sources that may contain extensive discussions regarding architecture violations, while there is a limited understanding of violation symptoms from the viewpoint of developers
Understanding software architecture erosion: A systematic mapping study
Architecture erosion (AEr) can adversely affect software development and has received significant attention in the last decade. However, there is an absence of a comprehensive understanding of the state of research about the reasons and consequences of AEr, and the countermeasures to address AEr. This work aims at systematically investigating, identifying, and analyzing the reasons, consequences, and ways of detecting and handling AEr. With 73 studies included, the main results are as follows: (1) AEr manifests not only through architectural violations and structural issues but also causing problems in software quality and during software evolution; (2) non-technical reasons that cause AEr should receive the same attention as technical reasons, and practitioners should raise awareness of the grave consequences of AEr, thereby taking actions to tackle AEr-related issues; (3) a spectrum of approaches, tools, and measures has been proposed and employed to detect and tackle AEr; and (4) three categories of difficulties and five categories of lessons learned on tackling AEr were identified. The results can provide researchers a comprehensive understanding of AEr and help practitioners handle AEr and improve the sustainability of their architecture. More empirical studies are required to investigate the practices of detecting and addressing AEr in industrial settings